class TreeNode:
    def __init__(self,val=0,left=None,right=None):
        self.val=val
        self.left=left
        self.right=right

class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next


print("两数之和"
      "数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标")
def liangshuzhihe(nums:list[int],target:int)->list[int]:
    tem_dict={}
    for k,v in enumerate(nums):
        if target-v in tem_dict:
            return [tem_dict[target-v],k]
        tem_dict[v]=k

print("最长公共前缀")
def zuichanggonggongqianzhui(strs:list[str])->str:
    strs.sort(key=lambda s:len(s))
    prefix=""
    for i in range(0,len(strs[0])):
        tem=len(set([ss[i] for ss in strs]))
        if tem==1:
            prefix=prefix+strs[0][i]
        else:
            return prefix
    return prefix

print("有效的括号")
def youxiaokuohao01(strs:str)->bool:
    for i in range(0,len(strs)//2):
        strs=strs.replace("()","").replace("[]","").replace("{}","")
    return len(strs)==0
def youxiaokuohao02(strs:str)->bool:
    mapping={")":"(","}":"{","]":"["}
    stack=[]
    for s in strs:
        if s in mapping:
            if len(stack)==0:
                return False
            if stack.pop() != mapping[s]:
                return False
        else:
            stack.append(s)
    return len(stack)==0

print("合并两个有序链表"
      "将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的")
def hebingyouxulianbiao(list1:ListNode,list2:ListNode)->ListNode:
    if not list1:
        return list2
    if not list2:
        return list1
    new_head=ListNode()
    current=new_head
    while list1 and list2:
        if list1.val<=list2.val:
            current.next=list1
            list1=list1.next
        else:
            current.next=list2
            list2=list2.next
        current=current.next
    if not list1:
        current.next=list2
    if not list2:
        current.next=list1
    return new_head.next


print("删除有序数组中的重复项")
def shanchuchongfuxiang(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    for k,v in counter.items():
        if v>1:
            for i in range(1,v):
                nums.remove(k)
    return len(nums)

print("移除元素"
      "给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素。元素的顺序可能发生改变。"
      "然后返回 nums 中与 val 不同的元素的数量")
def yichuyuansu(nums:list[int],val:int)->int:
    count=nums.count(val)
    for c in range(0,count):
        nums.remove(val)
    return len(nums)




print("搜索插入位置"
      "定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置")
def charuweizhi(nums:list[int],target:int)->int:
    if target in nums:
        return nums.index(target)
    else:
        nums.append(target)
        nums.sort()
        return nums.index(target)

print("最后一个单词的长度")
def zuihoudancichangdu(strs:str)->int:
    return len(strs.split()[-1])

print("数组元素加1")
def shuzuyuansujia1(digits:list[int])->list[int]:
    tem_list=[0 for d in digits]
    tem_list[-1]=1
    d_index,t_index,jinwei=len(digits)-1,len(tem_list)-1,0
    res=[]
    while d_index>=0 or t_index>=0:
        tem=digits[d_index]+tem_list[t_index]+jinwei
        res.insert(0,tem%10)
        jinwei=tem//10
        d_index=d_index-1
        t_index=t_index-1
    if jinwei>0:
        res.insert(0,jinwei)
        return res
    else:
        return res



print("X的算数平方根"
      "由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去")
def suanshupingfanggen(x:int)->int:
    if x<=1:
        return x
    for i in range(2,x):
        tem=i**2
        if tem==x:
            return i
        if (i+1)**2 > x:
            return i


print("爬楼梯")
def palouti(n:int)->int:
    if n==0 or n==1:
        return 1
    return palouti(n-1)+palouti(n-2)
def palouti2(n:int)->int:
    res=[1,2]
    if n<=2:
        return res[n-1]
    while len(res)<n:
        res.append(res[-1]+res[-2])
    return res[-1]

print("删除排序链表中的重复元素")
def shanchuchongfuyuansu(head:ListNode)->ListNode:
    if not head:
        return head
    current=head
    while current.next:
        if current.val==current.next.val:
            current.next=current.next.next
        else:
            current=current.next
    return head


print("合并两个有序数组"
      "请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。"
      "注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，"
      "其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n")
def merge(nums1:list[int],m:int,nums2:list[int],n:int)->list[int]:
    nums1[m:]=nums2
    nums1.sort()


print("判断是不是相同的树")
def isSameTree(p:TreeNode,q:TreeNode):
    if not p and not q:
        return True
    if not p or not q or p.val!=q.val:
        return False
    return isSameTree(p.left,q.left) and isSameTree(p.right,q.right)

print("判断是不是对称二叉树")
def isSymmetric(root:TreeNode)->bool:
    def panduanzuoyoushuduichen(left:TreeNode,right:TreeNode)->bool:
        if not left and not right:
            return True
        if not left or not right or left.val!=right.val:
            return False
        return panduanzuoyoushuduichen(left.left,right.right) and panduanzuoyoushuduichen(left.right,right.left)
    if not root:
        return False
    else:
        return panduanzuoyoushuduichen(root.left,root.right)

print("二叉树的最大深度")
def maxDepth(root:TreeNode)->int:
    if not root:
        return 0
    return max(maxDepth(root.left),maxDepth(root.right))+1


print("判断是不是平衡二叉树"
      "二叉树的每个节点的左右子树的高度差的绝对值不超过 1，则二叉树是平衡二叉树。"
      "根据定义，一棵二叉树是平衡二叉树，当且仅当其所有子树也都是平衡二叉树，因此可以使用递归的方式判断二叉树是不是平衡二叉树，"
      "递归的顺序可以是自顶向下或者自底向上。"
      "1、每一个节点的左子结点和右子节点高度不能大于1"
      "2、每一个节点同时也是平衡二叉树")
def isBalanced(root:TreeNode)->bool:
    def height(node:TreeNode):
        if not node:
            return 0
        return max(height(node.left),height(node.right))+1
    if not root:
        return True
    else:
        return abs(height(root.left)-height(root.right))<=1 and isBalanced(root.left) and isBalanced(root.right)


print("树的最小深度")
def minDepth(root:TreeNode)->int:
    if not root:
        return 0
    if not root.left:
        return minDepth(root.right)+1
    if not root.right:
        return minDepth(root.left)+1
    min_left=minDepth(root.left)
    min_right=minDepth(root.right)
    return min(min_left,min_right)+1

print("路径总和"
      "判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。"
      "如果存在，返回 true ；否则，返回 false 。")
def lujingzonghe(root:TreeNode,targetSum:int)->bool:
    def inner(node:TreeNode,target):
        if not node:
            return False
        target=target-node.val
        if node.left is None and node.right is None:
            return target==0
        return inner(node.left,target) or inner(node.right,target)
    return inner(root,targetSum)



print("给定一个非负整数n，返回杨辉三角的前n行")
def yanghuisanjiao001(numRows:int)->list[int]:
    source_list=[[1]*i for i in range(1,numRows+1)]
    if numRows<3:
        return source_list
    for i in range(2,numRows):
        for j in range(1,len(source_list[i])-1):
            source_list[i][j]=source_list[i-1][j-1]+source_list[i-1][j]
    return source_list


print("给定一个非负索引 rowIndex，返回「杨辉三角」的第 rowIndex 行")
def yanghuisanjiao002(numRows:int)->list[int]:
    source_list=[[1]*(i+1) for i in range(0,numRows+1)]
    if numRows<=1:
        return source_list[numRows]
    for i in range(2,numRows+1):
        for j in range(1,len(source_list[i])-1):
            source_list[i][j]=source_list[i-1][j-1]+source_list[i-1][j]
    return source_list[numRows]



print("买卖股票的最佳时机")
def maimaigupiao(prices:list[int])->int:
    min_price=prices[0]
    max_profit=0
    for p in prices:
        min_price=min(min_price,p)
        max_profit=max(max_profit,p-min_price)
    return max_profit


print("验证回文串"
      "如果在将所有大写字符转换为小写字符、并移除所有非字母数字字符之后，短语正着读和反着读都一样。则可以认为该短语是一个 回文串"
      "字母和数字都属于字母数字字符")
def yanzhenghuiwenchuan(s:str)->bool:
    tem_list=[]
    for tem in s:
        if tem.isdigit():
            tem_list.append(tem)
        if tem.isalpha():
            print("1111")
            tem_list.append(tem.lower())
    print(tem_list)
    return tem_list==tem_list[::-1]
yanzhenghuiwenchuan("race a car")


print("只出现一次的元素"
      "给你一个 非空 整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素")
def zhichuxainyiciyuansu(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    for k,v in counter.items():
        if v==1:
            return k



print("判断是不是环形链表")
def huanxinglianbiao(head:ListNode)->bool:
    if not  head:
        return False
    fast=head
    slow=head
    while fast:
        if fast.next is None or fast.next is None:
            return False
        fast=fast.next.next
        slow=slow.next
        if fast==slow:
            return True
    return False


print("前序遍历")
def qianxubianli(root:TreeNode)->list[int]:
    res_list=[]
    def inner(node:TreeNode):
        if not node:
            return
        res_list.append(node.val)
        inner(node.left)
        inner(node.right)
    inner(root)
    return res_list

print("中序遍历")
def zhongxubianli(root:TreeNode)->list[int]:
    res_list=[]
    def inner(node:TreeNode):
        if not node:
            return
        inner(node.left)
        res_list.append(node.val)
        inner(node.right)
    inner(root)
    return res_list
print("后续遍历")
def houxubianli(root:TreeNode)->list[int]:
    res_list=[]
    def inner(node:TreeNode):
        if not node:
            return
        inner(node.left)
        inner(node.right)
        res_list.append(node.val)
    inner(root)
    return res_list


print("返回相交链表的相交节点")
def xiangjiaojiedian(headA:ListNode,headB:ListNode)->ListNode:
    if not headA or not headB:
        return None
    tem_list=[]
    current=headA
    while current:
        tem_list.append(current)
        current=current.next

    current=headB
    while current:
        if current in tem_list:
            return current
        current=current.next
    return None




print("判断是不是多数元素"
      "给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素")
def duoshuyuansu(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    for k,v in counter.items():
        if v>len(nums)/2:
            return k


print("判断是不是快乐数"
      "各个位上的树反复相加，看最终结果是否能等于1")
def kuaileshu(n:int)->bool:
    cache_list=[]
    while True:
        tem=0
        for i in str(n):
            tem=int(i)**2+tem
        if tem==1:
            return True
        if tem in cache_list:
            return False
        cache_list.append(tem)
        n=tem





print("移除链表元素"
      "给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点")
def yichulianbiaoyuansu(head:ListNode,val:int)->ListNode:
    if not head:
        return None
    new_head=ListNode()
    new_head.next=head
    current=new_head
    while current.next:
        if current.next.val==val:
            current.next=current.next.next
        else:
            current=current.next
    return new_head.next

print("给定两个字符串，判定他们是否是同构字符串")
def tonggouzifuchuan(s:str,t:str)->bool:
    if not s and not t:
        return True
    if not s or not t:
        return False
    s_list=list(s)
    t_list=list(t)
    s_dict={}
    t_dict={}
    for k,v in zip(s_list,t_list):
        if k in s_dict:
            if s_dict[k]!=v:
                return False
        else:
            s_dict[k]=v
        if v in t_dict:
            if t_dict[v]!=k:
                return False
        else:
            t_dict[v]=k
    return True
print("反转链表")
class ListNode:
    def __init__(self,val=0,next=None):
        self.val=val
        self.next=next
def fanzhuanlianbiao(head:ListNode)->ListNode:
    if not head:
        return None
    pre=None
    current=head
    # 只要当前节点不为空，就要将当前节点指向上一个节点
    while current:
        tem=current.next
        current.next=pre
        pre=current
        current=tem
    return pre



print("存在重复元素 - 001"
      "简单的判断数组中是否有重复元素 有重复元素则返回true")
def chognfuyuansu01(nums:list[int])->bool:
    return  len(set(nums))!=len(nums)

print("存在重复元素 - 002"
      "给你一个整数数组 nums 和一个整数 k ，判断数组中是否存在两个 不同的索引 i 和 j ，"
      "满足 nums[i] == nums[j] 且 abs(i - j) <= k 。如果存在，返回 true ；否则，返回 false ")
def chongfuyuansu02(nums:list[int],k:int)->bool:
    tem_dict={}
    for i,v in enumerate(nums):
        if v in tem_dict:
            if abs(tem_dict[v]-i)<=k:
                return True
        tem_dict[v]=i
    return False


print("完全二叉树的节点个数")
def count_node(root:TreeNode) ->int:
    if not root:
        return 0
    return count_node(root.left)+count_node(root.right)+1


print("反转二叉树")
def fanzhuanerchashu(root:TreeNode)->TreeNode:
    if not root:
        return None
    left=fanzhuanerchashu(root.left)
    right=fanzhuanerchashu(root.right)
    root.left=right
    root.right=left
    return root

print("2的幂")
def mi_2(n:int)->bool:
    if n<=0:
        return False
    if n==1:
        return True
    res=1
    for i in range(0,n):
        res=res*2
        if res==n:
            return True
        if res>n:
            return False



print("回文链表")
def huiwenlianbiao(head:ListNode)->bool:
    if not head:
        return False
    current=head
    tem_list=[]
    while current:
        tem_list.append(current.val)
        current=current.next
    return tem_list==tem_list[::-1]

s1="abc"
s2="bcd"
s3="abc"
import collections
count1=collections.Counter(s1)
count2=collections.Counter(s2)
count3=collections.Counter(s3)
print(count1-count2)
print(len(count1-count2))
print(len(count3-count1))
print("有效的字母异位词"
      "字母异位词 是通过重新排列不同单词或短语的字母而形成的单词或短语，通常只使用所有原始字母一次"
      "判断 t 是否是 s 的字母异位词"
      "其实就是判断两个字符串长度是否相等  如果相等的话 两个字符串中每个字符出现的次数相等")
def yiweici(s:str,t:str)->bool:
    # import collections
    # s_counter=collections.Counter(s)
    # t_counter=collections.Counter(t)
    # if len(s_counter)!=len(t_counter):
    #     return False
    # res_counter_1=s_counter-t_counter
    # res_counter_2=t_counter-s_counter
    # return True if len(res_counter_1)==0 and len(res_counter_2)==0 else False

    import collections
    s_counter=collections.Counter(s)
    t_counter=collections.Counter(t)
    if len(s_counter)!=len(t_counter):
        return False
    for k,v in s_counter.items():
        if t_counter[k]!=v:
            return False
    return True


print(yiweici(s="nagaram",t="anagramm"))

print("各位相加"
      "给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。返回这个结果")
def geweixiangjia(num:int)->int:
    if num<10:
        return num
    while num>=10:
        tem_list=[int(n) for n in list(str(num))]
        tem=sum(tem_list)
        if tem<10:
            return tem
        num=tem




print("判断是不是丑数")
def choushu(n:int)->bool:
    if n<=0:
        return False

    factors=[2,3,5]
    for f in factors:
        while n%f==0:
            n=n//f
    return True if n==1 else False



print("丢失的数字"
      "给定一个包含 [0, n] 中 n 个数的数组 nums ，找出 [0, n] 这个范围内没有出现在数组中的那个数")
def diushideshuzi(nums:list[int])->int:
    import collections
    counter=collections.Counter(nums)
    for i in range(0,len(nums)+1):
        if counter[i]==0:
            return i

print("第一个错误版本")
def isBadVersion(i:int)->bool:
    pass
def firstbadversion(n:int)->int:
    left,right=1,n
    while left<=right:
        mid= (left+right)//2
        if isBadVersion(mid):
            right=mid-1
        else:
            left=mid+1
    return left


print("移动0"
      "编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序")
def yidong0(nums:list[int])->list[int]:
    count=nums.count(0)
    for i in range(0,count):
        nums.remove(0)
        nums.append(0)
    return nums


print("单词规律"
      "pattern = 'abba', s = 'dog cat cat dog'")
def danciguilv(pattern:str,s:str)->bool:
    p_list=list(pattern)
    s_list=s.split()
    if len(p_list)!=len(s_list):
        return False
    p_map={}
    s_map={}
    for k,v in zip(p_list,s_list):
        if k in p_map:
            if p_map[k] !=v:
                return False
        else:
            p_map[k]=v
        if v in s_map:
            if s_map[v]!=k:
                return False
        else:
            s_map[v]=k
    return True
print("nim游戏")
def nim(n:int)->bool:
    return not n%4==0


print("3的幂")
def mi_3(n:int)->bool:
    if n==0:
        return False
    if n==1:
        return True
    res=1
    while True:
        res=res*3
        if res==n:
            return True
        if res>n:
            return False

print("4的幂")
def mi_4(n:int)->bool:
    if n ==0:
        return False
    if n==1:
        return True
    res=1
    for i in range(0,n):
        res=res*4
        if res==n:
            return True
        if res>n:
            return False

print("不额外分配空间翻转字符串")
def fanzhuanstr(s:list[str])->list[str]:
    for i in range(0,len(s)//2):
        s[i],s[len(s)-1-i]=s[len(s)-1-i],s[i]
    return s


print("反转字符串中的元音字母"
      "只有两个索引位置的值都是原因字母时才翻转")
def fanzhuanyuanyin(s:str)->str:
    yuanyin="aeiouAEIOU"
    chars=list(s)
    left,right=0,len(chars)-1
    while left<=right:
        if chars[left] not in yuanyin:
            left+=1
        elif chars[right] not in yuanyin:
            right-=1
        else:
            chars[left],chars[right]=chars[right],chars[left]
            left=left+1
            right=right-1
    return "".join(chars)


print("两个数组的交集"
      "每个元素只出现一次")
def intersect2(nums1:list[int],nums2:list[int])->list[int]:
    import collections
    n1_counter=collections.Counter(nums1)
    n2_counter=collections.Counter(nums2)
    return list(n1_counter&n2_counter)


print("两个数组的交集"
      "给你两个整数数组 nums1 和 nums2 ，请你以数组形式返回两数组的交集。"
      "返回结果中每个元素出现的次数，应与元素在两个数组中都出现的次数一致"
      "（如果出现次数不一致，则考虑取较小值）。可以不考虑输出结果的顺序。")
def intersect(nums1:list,nums2:list)->list[int]:
    import collections
    n1_counter=collections.Counter(nums1)
    n2_counter=collections.Counter(nums2)
    return list((n1_counter&n2_counter).elements())


print("有效的完全平方数"
      "完全平方数 是一个可以写成某个整数的平方的整数。换句话说，它可以写成某个整数和自身的乘积。")
def youxiaowanquanpingfangshu(num:int)->bool:
    if num==0:
        return True
    for i in range(1,num+1):
        if i**2==num:
            return True
        if (i+1)**2>num:
            return False

print("二分法猜数字大小")
def guess(num:int)->bool:
    pass
def guessnumber(n:int)->int:
    left,right=1,n
    while left<=right:
        mid=(left+right)//2
        if guess(mid)==0:
            return mid
        elif guess(mid)<0:
            right=mid-1
        else:
            left=mid+1
    return -1


print("给你两个字符串：ransomNote 和 magazine ，判断 ransomNote 能不能由 magazine 里面的字符构成"
      "magazine 中的每个字符只能在 ransomNote 中使用一次")
def canconstruct(ransomNote:str,magazine:str)->bool:
    import collections
    m_counter=collections.Counter(magazine)
    for k,v in enumerate(ransomNote):
        m_counter[v]=m_counter[v]-1
        if m_counter[v]<0:
            return False
    return True


print("给定一个字符串 s ，找到 它的第一个不重复的字符，并返回它的索引 。如果不存在，则返回 -1")
def findfirstchar(s:str)->int:
    import collections
    s_counter=collections.Counter(s)
    for k,v in enumerate(s):
        if s_counter[v]==1:
            return k
    return -1


print("找不同找出随机添加的字符串 "
      "字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。"
      "请找出在 t 中被添加的字母。")
def finddiff(s:str,t:str)->str:
    import collections
    s_counter=collections.Counter(s)
    t_counter=collections.Counter(t)
    return list(t_counter-s_counter)[0]


print("判断子序列  s是不是t的子序列"
      "字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。"
      "（例如，'ace'是'abcde'的一个子序列，而'aec'不是）")
def zixulie(s:str,t:str)->bool:
    if not s:
        return True
    i=0
    for tt in t:
        if tt ==s[i]:
            i=i+1
            if i==len(s):
                return True
    return False

print("给定二叉树的根节点 root ，返回所有左叶子之和")
def zuoyezihe(root:TreeNode)->int:
    sum=0
    def inner(node:TreeNode):
        if not node:
            return 0
        if node.left and not node.left.left and not node.left.right:
            nonlocal sum
            sum=sum+node.left.val
        inner(node.left)
        inner(node.right)
    inner(root)
    return sum

print("返回最长回文串")
def zuichanghuiwenchuan(s:str)->int:
    import collections
    counter=collections.Counter(s)
    res=0
    tem=0
    for k,v in counter.items():
        if v%2==0:
            res=res+v
        else:
            res=res+(v//2)*2
            tem=1
    return res+tem


print("返回数组中第三大的数")
def max_3(nums:list[int]) ->int:
    nums=sorted(list(set(nums)))
    return nums[-1] if len(nums)<3 else nums[-3]


print("字符串相加"
      "给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和并同样以字符串形式返回")
def strxiangjia(num1:str,num2:str)->str:
    one_list=[int(n) for n in num1]
    two_list = [int(n) for n in num2]
    o,t=len(one_list)-1,len(two_list)-1
    jinwei=0
    res=""
    while o>=0 or t>=0:
        n1=one_list[o] if o>=0 else 0
        n2=two_list[t] if t>=0 else 0
        tem=n1+n2+jinwei
        res=str(tem%10)+res
        jinwei=tem//10
        o=o-1
        t=t-1
    return str(jinwei)+res if jinwei>0 else res



print("返回字符串中的单词数"
      "这里的单词指的是连续的不是空格的字符")
def dancishu(s:str)->int:
    return len(s.split())


print("排列硬币-返回完整阶梯行")
def wanzhengjieti(n:int)->int:
    if n==0 or n==1:
        return n
    tem=0
    for i in range(1,n):
        tem=tem+i
        if tem==n:
            return i
        if tem>n:
            return i-1


print("找到 所有的 从数组中消失的数字")
def xiaoshishuzi(nums:list[int])->list[int]:
    import collections
    counter=collections.Counter(nums)
    res=[]
    for i in range(1,len(nums)+1):
        if counter[i]==0:
            res.append(i)
    return res



print("分发饼干")
def fenfabinggan(g:list[int],s:list[int])->int:
    g.sort()
    s.sort()
    res,child_index,cookie_index=0,0,0
    while child_index<len(g) and cookie_index<len(s):
        if g[child_index]<=s[cookie_index]:
            res=res+1
            child_index=child_index+1
            cookie_index=cookie_index+1
        else:
            cookie_index=cookie_index+1
    return res



print("重复的子字符串"
      "给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成")
def chongfuzizifuchuan(s:str)->bool:
    for i in range(1,len(s)):
        flag=len(s)%len(s[0:i])
        if flag==0:
            tem=s[::]
            count=len(s)//len(s[0:i])
            for c in range(0,count):
                tem=tem.replace(s[0:i],"")
            if len(tem) ==0:
                return True
    return False

try:
    print(None+1)
except Exception:
    print(Exception)